package com.qf.talk.service.impl;

import com.qf.talk.dao.*;
import com.qf.talk.model.*;
import com.qf.talk.service.FriendService;
import com.qf.talk.vo.FriendVO;
import net.minidev.json.writer.FakeMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
public class FriendServiceImpl implements FriendService {
    @Resource
    private FriendBaseDao friendBaseDao;
    @Resource
    private FriendRelationDao friendRelationDao;
    @Resource
    private FriendRequestAddDao friendRequestAddDao;
    @Resource
    private UserCacheDao userCacheDao;
    @Resource
    private UserCacheMapper userCacheMapper;


    @Resource
    private FriendVOMapper friendVOMapper;

    @Transactional(rollbackFor = Exception.class)
    @Override
    public int addFriend(Long userId, Long wantUserId, String message) {
        //首先需要判断两个人的好友关系是否满足要求
        //如果已经是好友就回复已经是好友
        //当一个人想加另一个人的时候
        //携带的messagese信息，的含义是随着被添加人的好友策略决定的
        //如果被添加人的策略是 1 随意添加  验证毫无意义
        //                   2验证信息  代表问题的答案
        //                   3代表好友的密码
        //                   4 代表验证信息本身
        //所以，第一件事：根据wantUserId查询好友策略
        if (userId==null&&wantUserId==null){
            return -1;
        }
        FriendBaseExample example=new FriendBaseExample();
        FriendBaseExample.Criteria criteria=example.createCriteria();
        criteria.andUserIdEqualTo(wantUserId);
        //FriendBase是个人用户可以被人添加的表
        //Friendgroup是好友的分类表
        //Friendrelation是朋友相互关系表
        //Friendrequest add好友请求添加信息表
        //userFriendshippolicy 类型表
        List<FriendBase> friendBases = friendBaseDao.selectByExample(example);
        int result=0;
        FriendRelationExample friendRelationExample=new FriendRelationExample();
        FriendRelationExample.Criteria criteria2 = friendRelationExample.createCriteria();
        criteria2.andCreateIdEqualTo(userId);
        criteria2.andCreateIdEqualTo(wantUserId);
        List<FriendRelation> friendRelations=friendRelationDao.selectByExample(friendRelationExample);
        if (friendRelations!=null&&friendRelations.size()>0){
            return -1;
        }
        if (friendBases!=null&&friendBases.size()>0){
            //取出好友策略
            FriendBase friendBase=friendBases.get(0);
            Integer policyId=friendBase.getFriendShipPolicyId();
            if (policyId==0){
                return -1;
            }else if (policyId==1){
                //随意添加
                result=1;
            }else if (policyId==2){
                //验证问题的方式，message代表了问题的答案
                //查询问题的答案和message事赋equals
                if ((friendBase.getFriendPolicyAnswer()+"").equals(message)){
                    //可以添加
                    result=1 ;
                }else {
                    //添加失败
                    result=-1;
                }
            }else if (policyId==3){
                //输入密码的方式添加好友，message代表了密码
                //查询出来的密码和message对比，是否equals
                if((friendBase.getFriendPolicyPassword()+"").equals(message)){
                    //密码正确，可以添加
                    result=1;
                }else {
                    //密码错误，不可以添加
                    result=-1;
                }
            }else if (policyId==4){
                //验证信息添加方式，message就是验证信息
                //将验证信息入库即可，
                FriendRequestAdd friendRequestAdd=new FriendRequestAdd();
                friendRequestAdd.setMessage(message);
                friendRequestAdd.setUserId(userId);
                friendRequestAdd.setRequestUserId(wantUserId);
                friendRequestAdd.setState(0);
                friendRequestAddDao.insertSelective(friendRequestAdd);
                result=2;
            }
            if (result==1){
                //修改数据库，给两个用户添加好友关系
                //我们数据库维护的是双向的关系
                //对于张三添加里斯的问题
                //好友表要保证张三的好友李四
                //还要保存李四的好友张三
                FriendRelation friendRelation = new FriendRelation();
                friendRelation.setUserId(userId);
                friendRelation.setFriendId(wantUserId);
                friendRelationDao.insertSelective(friendRelation);
                friendRelation.setUserId(wantUserId);
                friendRelation.setFriendId(userId);
                friendRelationDao.insertSelective(friendRelation);
            }
        }
        return result;



    }

    @Override
    public int askRequest(Long requestId, Integer state,Long selfId) {

        //1查requestId -> userId,requestUserId

        FriendRequestAdd friendRequestAdd=friendRequestAddDao.selectByPrimaryKey(requestId);
        if (!selfId.equals(friendRequestAdd.getRequestUserId())){
            //判断被请求人是不是自己，不是自己，自己没有资格同意或者拒绝
            return -1;
        }
        //2、一次把所有(userId,requestUserId)对应的请求的状态都置为state
        //设置更新的条件
        FriendRequestAddExample example=new FriendRequestAddExample();
        FriendRequestAddExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(friendRequestAdd.getUserId());
        criteria.andRequestUserIdEqualTo(friendRequestAdd.getRequestUserId());
        //设置更新的值
        FriendRequestAdd temp=new FriendRequestAdd();
        temp.setState(state);

        friendRequestAddDao.updateByExample(temp,example);
        //2 一次把所有userId,requestUserId对应的请求的状态都设置为state
        //3当state==1时，为双方添加双向的好友关系
        if (state==1){
            //代表同意
            FriendRelation friendRelation=new FriendRelation();
            long userId=friendRequestAdd.getUserId();
            long wantUserId=friendRequestAdd.getRequestUserId();
            //首先需要判断两个人的好友关系是否已经满足要求

            //修改数据库，给两个用户添加好友关系
            //我们数据库维护的是双向的关系
            //对于张三添加李四的问题
            //好友表要保存张三的好友李四
            //还要保存李四的好友张三
            //校验正向关系
            FriendRelationExample friendRelationExample=new FriendRelationExample();
            FriendRelationExample.Criteria criteria1 = friendRelationExample.createCriteria();
            criteria1.andUserIdEqualTo(userId);
            criteria1.andFriendIdEqualTo(wantUserId);
            List<FriendRelation> friendRelations = friendRelationDao.selectByExample(friendRelationExample);
            if (friendRelations==null&&friendRelations.size()<0) {
                friendRelation.setUserId(userId);
                friendRelation.setFriendId(wantUserId);
                friendRelationDao.insertSelective(friendRelation);
            }
            //调转添加人和被添加人，反向再存一个好友关系
            friendRelationExample=new FriendRelationExample();
            criteria1 = friendRelationExample.createCriteria();
            criteria1.andUserIdEqualTo(wantUserId);
            criteria1.andFriendIdEqualTo(userId);
            friendRelations = friendRelationDao.selectByExample(friendRelationExample);
            if(!(friendRelations!=null&&friendRelations.size()>0)) {
                friendRelation.setUserId(wantUserId);
                friendRelation.setFriendId(userId);
                friendRelationDao.insertSelective(friendRelation);
            }
        }
        return state;
    }

    @Override
    public List<FriendVO> findFriends(Long userId) {

        return friendVOMapper.findFriendVoByUserId(userId);
    }

    @Override
    public List<FriendRequestAdd> findRequestAdd(Long userId) {
        //userId是被请求人，千万别在请求表里和user_id字段判断
        FriendRequestAddExample example=new FriendRequestAddExample();
        FriendRequestAddExample.Criteria criteria = example.createCriteria();
        criteria.andRequestUserIdEqualTo(userId);
        //使用插件自动生成的代码进行order by
        example.setOrderByClause("create_time desc");
        return friendRequestAddDao.selectByExample(example);

    }

    @Override
    public List<UserCache> findUserCacheByIds(List<Long> userIds) {
        return userCacheMapper.findUserCachesByIds(userIds);
    }

    @Override
    public int updateUserCache(List<UserCache> users) {
        int result=0;
        for (int i=0;i<users.size();i++){
            result+= userCacheDao.updateByPrimaryKey(users.get(i));
        }

        return result;
    }

    @Override
    public int deleteFriend(Long userId, Long friendId) {
        //真删除，删前先查，放到另一张表里面，相当于冷数据
        //张三删除李四，请问，李四好友里面还有张三吗
        //单项删除
        FriendRelationExample example=new FriendRelationExample();
        FriendRelationExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(userId);
        criteria.andFriendIdEqualTo(friendId);
       return friendRelationDao.deleteByExample(example);
    }

    @Override
    public int editFriendMarkName(Long userId, Long friendId, String markName) {
        FriendRelationExample example=new FriendRelationExample();
        FriendRelationExample.Criteria criteria = example.createCriteria();
        criteria.andUserIdEqualTo(userId);
        criteria.andFriendIdEqualTo(friendId);
        FriendRelation friendRelation=new FriendRelation();
        friendRelation.setMarkName(markName);
        int i = friendRelationDao.updateByExampleSelective(friendRelation, example);


        return i;
    }

}
